package com.knowledge.plus.泛型.demo;

/**
 * 泛型练习：https://blog.csdn.net/m0_53140426/article/details/140571727
 *
 * @author TPF
 * @since 2024/9/4
 */
class GenericTests {

    public static void main(String[] args) {
        GenericTests generic = new GenericTests();
        // 1. 交换指定两个元素的位置
        String[] t1Res = generic.test1(new String[]{"你好", "亲爱的"}, 0, 1);
        // 2. 查找数组中的最大值
        Double t2Res = generic.test2(new Double[]{2.1, 9.6, 8.2, 6.0});
        Integer t2_1Res = generic.test2(new Integer[]{2, 9, 8, 6});
        // 3. 打印数组中的所有元素
        generic.test3(new String[]{"hello", "world", "!"});
        // 4. 计算数组中所有元素的总和
        double t4Res = generic.test4(new Integer[]{1, 5, 4});
        // 5. 复制一个泛型数组
        String[] t5Res = generic.test5(new String[]{"hello", "world", "!"});
        // 6. 打印两个泛型对象的字符串表示
        generic.test6("你好帅！", 123); // t:字符串类型，e:整型
        // 7. 打印两个泛型变量的类型
        generic.test7("你好帅！", 123);

    }



    /**
     * 打印两个泛型变量的类型
     */
    private <T, E> void test7(T t, E e) {
        System.out.println("泛型T的类型：" + t.getClass().getSimpleName());
        System.out.println("泛型E的类型：" + e.getClass().getSimpleName());
    }

    /**
     * 查找数组中的最大值
     */
    private <T extends Comparable<T>> T test2(T[] arr) {
        T max = arr[0];
        for (T item : arr) {
            if (item.compareTo(max) > 0) {
                max = item;
            }
        }
        return max;
    }

    /**
     * 计算数组中所有元素的总和
     */
    private <T extends Number> double test4(T[] arr) {
        double sum = 0;
        for (T item : arr) {
            sum += item.doubleValue();
        }
        return sum;
    }

    /**
     * 交换指定两个元素的位置
     */
    private <T> T[] test1(T[] t, int pos1, int pos2) {
        T temp = t[pos1];
        t[pos1] = t[pos2];
        t[pos2] = temp;
        return t;
    }

    /**
     * 打印数组中的所有元素
     */
    private <T> void test3(T[] arr) {
        for (T item : arr) {
            System.out.print(item + "\t");
        }
    }

    /**
     * 复制一个泛型数组
     */
    private <T> T[] test5(T[] arr) {
        return arr.clone();
    }

    /**
     * 打印两个泛型对象的字符串表示
     */
    private <T, E> void test6(T t, E e) {
        System.out.println("泛型T：" + t);
        System.out.println("泛型E：" + e);
    }

}
